<?php
/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 * Curl based implementation of apiIO.
 *
 * @author Chris Chabot <chabotc@google.com>
 * @author Chirag Shah <chirags@google.com>
 */
require_once 'Google_CacheParser.php';
class Google_CurlIO implements Google_IO
{
    const CONNECTION_ESTABLISHED = "HTTP/1.0 200 Connection established\r\n\r\n";
    const FORM_URLENCODED = 'application/x-www-form-urlencoded';
    private static $ENTITY_HTTP_METHODS = array('POST' => null, 'PUT' => null);
    private static $HOP_BY_HOP = array(
      'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
      'te', 'trailers', 'transfer-encoding', 'upgrade', );
    private $curlParams = array(
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_FOLLOWLOCATION => 0,
      CURLOPT_FAILONERROR => false,
      CURLOPT_SSL_VERIFYPEER => true,
      CURLOPT_HEADER => true,
      CURLOPT_VERBOSE => false,
  );
  /**
   * Perform an authenticated / signed apiHttpRequest.
   * This function takes the apiHttpRequest, calls apiAuth->sign on it
   * (which can modify the request in what ever way fits the auth mechanism)
   * and then calls apiCurlIO::makeRequest on the signed request
   *
   * @param Google_HttpRequest $request
   * @return Google_HttpRequest The resulting HTTP response including the
   * responseHttpCode, responseHeaders and responseBody.
   */
  public function authenticatedRequest(Google_HttpRequest $request)
  {
      $request = Google_Client::$auth->sign($request);

      return $this->makeRequest($request);
  }
  /**
   * Execute a apiHttpRequest
   *
   * @param Google_HttpRequest $request the http request to be executed
   * @return Google_HttpRequest http request with the response http code, response
   * headers and response body filled in
   * @throws Google_IOException on curl or IO error
   */
  public function makeRequest(Google_HttpRequest $request)
  {
      // First, check to see if we have a valid cached version.
    $cached = $this->getCachedRequest($request);
      if ($cached !== false) {
          if (Google_CacheParser::mustRevalidate($cached)) {
              $addHeaders = array();
              if ($cached->getResponseHeader('etag')) {
                  // [13.3.4] If an entity tag has been provided by the origin server,
          // we must use that entity tag in any cache-conditional request.
          $addHeaders['If-None-Match'] = $cached->getResponseHeader('etag');
              } elseif ($cached->getResponseHeader('date')) {
                  $addHeaders['If-Modified-Since'] = $cached->getResponseHeader('date');
              }
              $request->setRequestHeaders($addHeaders);
          } else {
              // No need to revalidate the request, return it directly
        return $cached;
          }
      }
      if (array_key_exists($request->getRequestMethod(),
          self::$ENTITY_HTTP_METHODS)) {
          $request = $this->processEntityRequest($request);
      }
      $ch = curl_init();
      curl_setopt_array($ch, $this->curlParams);
      curl_setopt($ch, CURLOPT_URL, $request->getUrl());
      if ($request->getPostBody()) {
          curl_setopt($ch, CURLOPT_POSTFIELDS, $request->getPostBody());
      }
      $requestHeaders = $request->getRequestHeaders();
      if ($requestHeaders && is_array($requestHeaders)) {
          $parsed = array();
          foreach ($requestHeaders as $k => $v) {
              $parsed[] = "$k: $v";
          }
          curl_setopt($ch, CURLOPT_HTTPHEADER, $parsed);
      }
      curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $request->getRequestMethod());
      curl_setopt($ch, CURLOPT_USERAGENT, $request->getUserAgent());
      $respData = curl_exec($ch);
    // Retry if certificates are missing.
    if (curl_errno($ch) == CURLE_SSL_CACERT) {
        error_log('SSL certificate problem, verify that the CA cert is OK.'
        .' Retrying with the CA cert bundle from google-api-php-client.');
        curl_setopt($ch, CURLOPT_CAINFO, dirname(__FILE__).'/cacerts.pem');
        $respData = curl_exec($ch);
    }
      $respHeaderSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
      $respHttpCode = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
      $curlErrorNum = curl_errno($ch);
      $curlError = curl_error($ch);
      curl_close($ch);
      if ($curlErrorNum != CURLE_OK) {
          throw new Google_IOException("HTTP Error: ($respHttpCode) $curlError");
      }
    // Parse out the raw response into usable bits
    list($responseHeaders, $responseBody) =
          self::parseHttpResponse($respData, $respHeaderSize);
      if ($respHttpCode == 304 && $cached) {
          // If the server responded NOT_MODIFIED, return the cached request.
      if (isset($responseHeaders['connection'])) {
          $hopByHop = array_merge(
          self::$HOP_BY_HOP,
          explode(',', $responseHeaders['connection'])
        );
          $endToEnd = array();
          foreach ($hopByHop as $key) {
              if (isset($responseHeaders[$key])) {
                  $endToEnd[$key] = $responseHeaders[$key];
              }
          }
          $cached->setResponseHeaders($endToEnd);
      }

          return $cached;
      }
    // Fill in the apiHttpRequest with the response values
    $request->setResponseHttpCode($respHttpCode);
      $request->setResponseHeaders($responseHeaders);
      $request->setResponseBody($responseBody);
    // Store the request in cache (the function checks to see if the request
    // can actually be cached)
    $this->setCachedRequest($request);
    // And finally return it
    return $request;
  }
  /**
   * @visible for testing.
   * Cache the response to an HTTP request if it is cacheable.
   * @param Google_HttpRequest $request
   * @return bool Returns true if the insertion was successful.
   * Otherwise, return false.
   */
  public function setCachedRequest(Google_HttpRequest $request)
  {
      // Determine if the request is cacheable.
    if (Google_CacheParser::isResponseCacheable($request)) {
        Google_Client::$cache->set($request->getCacheKey(), $request);

        return true;
    }

      return false;
  }
  /**
   * @visible for testing.
   * @param Google_HttpRequest $request
   * @return Google_HttpRequest|bool Returns the cached object or
   * false if the operation was unsuccessful.
   */
  public function getCachedRequest(Google_HttpRequest $request)
  {
      if (false == Google_CacheParser::isRequestCacheable($request)) {
          false;
      }

      return Google_Client::$cache->get($request->getCacheKey());
  }
  /**
   * @param $respData
   * @param $headerSize
   * @return array
   */
  public static function parseHttpResponse($respData, $headerSize)
  {
      if (stripos($respData, self::CONNECTION_ESTABLISHED) !== false) {
          $respData = str_ireplace(self::CONNECTION_ESTABLISHED, '', $respData);
      }
      if ($headerSize) {
          $responseBody = substr($respData, $headerSize);
          $responseHeaders = substr($respData, 0, $headerSize);
      } else {
          list($responseHeaders, $responseBody) = explode("\r\n\r\n", $respData, 2);
      }
      $responseHeaders = self::parseResponseHeaders($responseHeaders);

      return array($responseHeaders, $responseBody);
  }
    public static function parseResponseHeaders($rawHeaders)
    {
        $responseHeaders = array();
        $responseHeaderLines = explode("\r\n", $rawHeaders);
        foreach ($responseHeaderLines as $headerLine) {
            if ($headerLine && strpos($headerLine, ':') !== false) {
                list($header, $value) = explode(': ', $headerLine, 2);
                $header = strtolower($header);
                if (isset($responseHeaders[$header])) {
                    $responseHeaders[$header] .= "\n".$value;
                } else {
                    $responseHeaders[$header] = $value;
                }
            }
        }

        return $responseHeaders;
    }
  /**
   * @visible for testing
   * Process an http request that contains an enclosed entity.
   * @param Google_HttpRequest $request
   * @return Google_HttpRequest Processed request with the enclosed entity.
   */
  public function processEntityRequest(Google_HttpRequest $request)
  {
      $postBody = $request->getPostBody();
      $contentType = $request->getRequestHeader('content-type');
    // Set the default content-type as application/x-www-form-urlencoded.
    if (false == $contentType) {
        $contentType = self::FORM_URLENCODED;
        $request->setRequestHeaders(array('content-type' => $contentType));
    }
    // Force the payload to match the content-type asserted in the header.
    if ($contentType == self::FORM_URLENCODED && is_array($postBody)) {
        $postBody = http_build_query($postBody, '', '&');
        $request->setPostBody($postBody);
    }
    // Make sure the content-length header is set.
    if (!$postBody || is_string($postBody)) {
        $postsLength = strlen($postBody);
        $request->setRequestHeaders(array('content-length' => $postsLength));
    }

      return $request;
  }
  /**
   * Set options that update cURL's default behavior.
   * The list of accepted options are:
   * {@link http://php.net/manual/en/function.curl-setopt.php]
   *
   * @param array $optCurlParams Multiple options used by a cURL session.
   */
  public function setOptions($optCurlParams)
  {
      foreach ($optCurlParams as $key => $val) {
          $this->curlParams[$key] = $val;
      }
  }
}
